/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_Studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "当前默认操作数据.h"

#include <core/动画/curve.h>
#include <材质/材质.h>
#include <物体/S_物体.h>

#include <stack>
#include "../异步解算\物理异步解算.h"
#include "节点/节点.h"
#include "节点/编译声明代码.h"
#include "节点编辑.h"

#include "虚拟体物体构建.h"
#include "数据创建销毁.h"


static std::map<S_物体*, C_节点基类*> g_能在场景视口中显示的物体节点;



S_RGBA8UI S_节点UI主题::uic_I8;
S_RGBA8UI S_节点UI主题::uic_UI8;
S_RGBA8UI S_节点UI主题::uic_I16;
S_RGBA8UI S_节点UI主题::uic_UI16;
S_RGBA8UI S_节点UI主题::uic_I32;
S_RGBA8UI S_节点UI主题::uic_UI32;
S_RGBA8UI S_节点UI主题::uic_I64;
S_RGBA8UI S_节点UI主题::uic_UI64;
S_RGBA8UI S_节点UI主题::uic_F32;
S_RGBA8UI S_节点UI主题::uic_vec2;
S_RGBA8UI S_节点UI主题::uic_vec3;
S_RGBA8UI S_节点UI主题::uic_vec4;
S_RGBA8UI S_节点UI主题::uic_mat2X2;
S_RGBA8UI S_节点UI主题::uic_mat3X2;
S_RGBA8UI S_节点UI主题::uic_mat4X2;
S_RGBA8UI S_节点UI主题::uic_mat2X3;
S_RGBA8UI S_节点UI主题::uic_mat3X3;
S_RGBA8UI S_节点UI主题::uic_mat4X3;
S_RGBA8UI S_节点UI主题::uic_mat4X4;
S_RGBA8UI S_节点UI主题::uic_对象;
S_RGBA8UI S_节点UI主题::uic_物体;
S_RGBA8UI S_节点UI主题::uic_解算器;

S_RGBA8UI S_节点UI主题::uic_模型面 = { 180, 180, 180, 255 };
S_RGBA8UI S_节点UI主题::uic_模型线 = { 20, 20, 20, 255 };
S_RGBA8UI S_节点UI主题::uic_模型点 = { 80,255,80,255 };
S_RGBA8UI S_节点UI主题::uic_模型焦点 = { 230, 120, 80, 255 };
S_RGBA8UI S_节点UI主题::uic_空间曲线 = { 0, 0, 0, 255 };
S_RGBA8UI S_节点UI主题::uic_摄像机虚拟体 = { 120, 230, 80, 255 };


S_RGBA8UI S_节点UI主题::uic_链接线 = { 100, 100, 100, 255 };
S_RGBA8UI S_节点UI主题::uic_链接线链接 = {200, 255, 150, 255};

S_RGBA8UI S_节点UI主题::uic_主线辅线 = {128,128,128,150};
S_RGBA8UI S_节点UI主题::uic_网格辅线 = {127,127,127,150};
S_RGBA8UI S_节点UI主题::uic_刻度线L1 = { 60, 60, 60, 255 };
S_RGBA8UI S_节点UI主题::uic_刻度线L2 = { 25, 25, 25, 255 };

S_RGBA8UI S_节点UI主题::uic_骨骼面物体状态 = { 200, 200, 200, 255 };
S_RGBA8UI S_节点UI主题::uic_骨骼边物体状态 = { 10, 10, 10, 255 };
S_RGBA8UI S_节点UI主题::uic_骨骼面编辑状态 = { 197, 197, 197, 255 };
S_RGBA8UI S_节点UI主题::uic_骨骼边编辑状态 = { 200, 200, 197, 255 };
S_RGBA8UI S_节点UI主题::uic_骨骼编辑焦点 = { 250, 250, 200, 255 };
S_RGBA8UI S_节点UI主题::uic_骨节编辑焦点 = { 250, 230, 150, 255 };

std::string	S_节点UI主题::ui_默认字体 = "雅黑";
std::string	S_节点UI主题::ui_节点图标 = "节点ICO";






void f_NodeCtx_状态属性初始化() {
	f_prop_Bool(S_NodeCtx_模拟计算::g_是否开启解算) = false;
	S_NodeCtx_模拟计算::g_是否开启解算.m_私有 = true;
	f_prop_Bool(S_NodeCtx_模拟计算::g_节点解算) = false;
	S_NodeCtx_模拟计算::g_节点解算.m_私有 = true;


	S_节点数据::g_场景帧.帧区间 = { 0, 400 };
	S_节点数据::g_场景帧.当前帧 = 0;


	S_节点数据状态::g_是否打开了编辑模式 = f_alloc_BoolProp(nullptr, u"是否开启编辑模式");
	S_节点数据状态::g_是否打开了编辑模式.m_私有 = true;
	f_prop_Bool(S_节点数据状态::g_是否打开了编辑模式) = false;

	S_节点数据状态::g_网格编辑模式 = f_alloc_EnumProp(nullptr, { {u"物体模式", u"物体"}, {u"编辑模式", u"三角顶点"}, {u"编辑权重", u"lab4"}, {u"绘制纹理", u"brush"} }, u"网格编辑");
	S_节点数据状态::g_骨架编辑模式 = f_alloc_EnumProp(nullptr, { {u"物体模式", u"骨架"}, {u"编辑模式", u"编辑骨骼"}, {u"姿态模式", u"姿态编辑"} }, u"骨架编辑");
	S_节点数据状态::g_灯光编辑模式 = f_alloc_EnumProp(nullptr, { {u"物体模式", u""}, {u"编辑模式", u""} }, u"灯光编辑");

	S_节点数据状态::g_网格编辑模式.m_私有 = true;
	S_节点数据状态::g_骨架编辑模式.m_私有 = true;
	S_节点数据状态::g_灯光编辑模式.m_私有 = true;

	S_节点数据状态::g_骨骼编辑模式 = f_alloc_EnumProp(nullptr, { {u"旋转",u"骨骼"}, {u"拉扯",u"骨骼拖拽"} }, u"姿态编辑模式");
	S_节点数据状态::g_骨骼编辑模式.m_私有 = true;
	S_节点数据状态::g_骨骼姿态编辑模式 = f_alloc_EnumProp(nullptr, { {u"旋转",u"骨骼"}, {u"拉扯",u"骨骼拖拽"} }, u"姿态编辑模式");
	S_节点数据状态::g_骨骼姿态编辑模式.m_私有 = true;


	S_节点数据状态::g_3D视口显示模式 = f_alloc_EnumProp(nullptr,
		{ {u"点显示", u"点阵"}, {u"线显示", u"网格"}, {u"面显示", u"球"}, {u"材质显示", u"05_关照多维材质"} },
		u"显示模式",
		2);
	S_节点数据状态::g_3D视口显示模式.m_私有 = true;

	S_节点数据::g_物理引擎视口互交.m_私有 = true;
	f_prop_Bool(S_节点数据::g_物理引擎视口互交) = false;



	S_节点数据::g_物体显示模式项_光追 = f_Prop位域枚举_项填充(S_节点UI数据::g_物体显示模式标题和图标);

	S_节点数据::g_对称轴枚举项 = f_Prop位域枚举_项填充(
		{
			{u"X",	u"X"},
			{u"Y",	u"Y"},
			{u"Z",	u"Z"},
		}
	);

	S_节点数据::g_图像文件后缀 = f_Prop位域枚举_项填充(
		{
			{u".jpg", u""},
			{u".png", u""},
			{u".hdr", u""},
			{u".bmp", u""},
			{u".tga", u""},
		}
	);
	S_节点数据::g_视频文件后缀 = f_Prop位域枚举_项填充(
		{
			{u".mp4", u""},
			//{L".png", ""},
			//{L".hdr", ""},
			//{L".bmp", ""},
			//{L".tga", ""},
		}
	);
	S_节点数据::g_粒子包含属性 = f_Prop位域枚举_项填充(
		{
			{u"位置", u""},
			{u"速度", u""},
			{u"旋转", u""},
			{u"大小", u""},
			{u"寿命", u""},
			{u"年龄", u""},
		}
	);


	std::vector<S_标题和图标> 渲染图层_标题和图标(E_RenderLayerType::e_renderLayer_end);
	渲染图层_标题和图标[E_RenderLayerType::e_renderLayer_composite]		= { u"最终合成",	u"" };
	渲染图层_标题和图标[E_RenderLayerType::e_renderLayer_diffuse]		= { u"漫反射",		u"" };
	渲染图层_标题和图标[E_RenderLayerType::e_renderLayer_depth]			= { u"深度",		u"" };
	渲染图层_标题和图标[E_RenderLayerType::e_renderLayer_normal]		= { u"法线",		u"" };
	渲染图层_标题和图标[E_RenderLayerType::e_renderLayer_illuminate]	= { u"自发光",		u"" };
	渲染图层_标题和图标[E_RenderLayerType::e_renderLayer_shadow]		= { u"光照",		u"" };
	S_节点UI数据::g_对称轴枚举项 = f_Prop位域枚举_项填充(渲染图层_标题和图标);

	std::vector<S_标题和图标> 物理可视项(2);
	物理可视项[0] = { u"粒子", u"" };
	物理可视项[1] = { u"体素", u"" };
	S_节点UI数据::g_物理可视项 = f_Prop位域枚举_项填充(物理可视项);

	S_节点数据::g_片源着色器类型项 = f_Prop位域枚举_项填充({ {u"光追"}, {u"光栅"} });


	

	S_节点数据::g_渲染层大纲数据 = new S_Object(E_物体类型::t_空);
	S_节点数据::g_渲染层大纲数据->m_是否展开 = true;

}

void f_NodeCtx_状态属性释放() {
	f_NodeCtx_等待计算完成();
	f_NodeCtx_清除状态属性数据();



	f_prop_Release(S_节点数据状态::g_是否打开了编辑模式);

	f_prop_Release(S_节点数据状态::g_网格编辑模式);
	f_prop_Release(S_节点数据状态::g_骨架编辑模式);
	f_prop_Release(S_节点数据状态::g_灯光编辑模式);


	f_Prop位域枚举_项销毁(S_节点数据::g_物体显示模式项_光追);
	f_Prop位域枚举_项销毁(S_节点数据::g_对称轴枚举项);
	f_Prop位域枚举_项销毁(S_节点数据::g_图像文件后缀);
	f_Prop位域枚举_项销毁(S_节点数据::g_视频文件后缀);

	f_Prop位域枚举_项销毁(S_节点UI数据::g_对称轴枚举项);
	f_Prop位域枚举_项销毁(S_节点UI数据::g_物理可视项);
	f_Prop位域枚举_项销毁(S_节点数据::g_片源着色器类型项);

	f_Prop位域枚举_项销毁(S_节点数据::g_粒子包含属性);


}

void f_NodeCtx_清除状态属性数据() {
	g_能在场景视口中显示的物体节点.clear();
	
	f_OE_销毁所有可编辑物体属性();

	f_scene_移除所有物体(f_NodeCtx_get默认场景(), E_场景物体容器类型::e_集合);
	
	S_节点数据::m_全局物体set.clear();
	S_节点数据::m_独立物体set.clear();

	f_代码构建_清除代码缓存();
}


void f_NodeCtx_初始化物体材质(S_设备环境& ctx) {

	//S_节点数据::g_单色平直面材质 = new S_单色平直面材质(ctx);
	//S_节点数据::g_单色面材质 = new S_单色面材质(ctx);
	//S_节点数据::g_单色线框材质 = new S_单色线框材质(ctx);
	//S_节点数据::g_单色描边材质 = new S_单色描边材质(ctx);
	//S_节点数据::g_单色线段材质 = new S_单色线段材质(ctx);
	//S_节点数据::g_单色连续线材质 = new S_单色连续线材质(ctx);
	//S_节点数据::g_单色连续虚线材质 = new S_单色虚线材质(ctx, true);
	//S_节点数据::g_单色线段虚线材质 = new S_单色虚线材质(ctx, false);
	//
	//S_节点数据::g_基本光照描边材质 = new S_基本光照描边材质(ctx);
	//S_节点数据::g_基本光照轮廓材质 = new S_基本光照描边材质(ctx, E_绘制方式::e_画邻接三角形);
	//S_节点数据::g_基本光照平面材质 = new S_面基本光照材质(ctx, false);
	//
	//S_节点数据::g_权重可视面材质 = new S_权重可视材质(ctx, E_填充模式::e_填充面);
	//S_节点数据::g_权重可视线材质 = new S_权重可视材质(ctx, E_填充模式::e_填充线);
	//
	//S_节点数据::g_索引绘制_颜色线段材质 = new S_索引绘制_基本颜色材质(ctx, E_绘制方式::e_画线段, E_填充模式::e_填充线);
	//S_节点数据::g_索引绘制_颜色线材质 = new S_索引绘制_基本颜色材质(ctx, E_绘制方式::e_画连续线, E_填充模式::e_填充线);
	//S_节点数据::g_索引绘制_颜色点材质 = new S_索引绘制_基本颜色材质(ctx, E_绘制方式::e_画点集, E_填充模式::e_填充点);
	//S_节点数据::g_索引绘制_图标材质 = new S_图标材质(ctx);
	//
	//
	//S_节点数据::g_单色点材质 = new S_单色点材质(ctx);
	//
	//S_节点数据::g逐顶点线段材质 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画线段);
	//S_节点数据::g逐顶点线段材质_朝向镜头 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画线段);
	//
	//S_节点数据::g逐顶点连续线材质 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画连续线);
	//S_节点数据::g_逐顶点线段描边材质 = new S_单色逐顶点线描边材质(ctx);
	//废弃
	//S_节点数据::g逐顶点_点材质 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画点集);
	//
	//
	//S_节点数据::g曲线材质 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画线段, E_填充模式::e_填曲线);
	//S_节点数据::g曲线控制点材质 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画点集, E_填充模式::e_填曲线控制点);
	//S_节点数据::g曲线控制线材质 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画点集, E_填充模式::e_填曲线控制线);
	//
	//
	//S_节点数据::g数值标注材质 = new S_数值标注材质(ctx);
	//S_节点数据::g数值标注线材质 = new S_数值标注材质(ctx, true);
	//S_节点数据::g包围盒材质 = new S_包围盒材质(ctx);
	//S_节点数据::g_AABB材质 = new S_AABB材质(ctx);
	//
	//S_节点数据::gFLIP可视预览材质 = new S_FLIP可视预览材质(ctx);
	//
	//
	//
	//S_节点数据::g物理光照轮廓材质 = f_material_createPBR();
	//S_线管创建参数 线管参数({ 1024, 1024 });
	//线管参数.m_绘制方式 = E_绘制方式::e_三角形;
	//线管参数.m_填充模式 = E_填充模式::e_填充面;
	//线管参数.m_采样 = ctx.m_采样数;
	//S_节点数据::g物理光照轮廓材质->mf_GPU参数配置 = (fp_set材质GPU参数配置)f_update轮廓着色器参数配置;
	//f_df_创建材质着色器(ctx, S_节点数据::g物理光照轮廓材质, f_node_轮廓线管配置(E_几何着色类型::e_几何着色_边), 线管参数);
	//
	//S_节点数据::g物理光照线材质 = f_material_createPBR();
	//线管参数.m_绘制方式 = E_绘制方式::e_画邻接连续线段;
	//线管参数.m_填充模式 = E_填充模式::e_填充面;
	//线管参数.m_采样 = ctx.m_采样数;
	//S_节点数据::g物理光照线材质->mf_GPU参数配置 = (fp_set材质GPU参数配置)f_update轮廓着色器参数配置;
	//f_df_创建材质着色器(ctx, S_节点数据::g物理光照线材质, f_node_轮廓线管配置(E_几何着色类型::e_几何着色_线), 线管参数);



	#pragma omp parallel sections 
	{
	#pragma omp section 
		{
			
			
		}
	//#pragma omp section 
	//	{
	//		assert(!S_节点数据::g_字体纹理采样器);
	//
	//		S_节点数据::g_字体纹理采样器 = f_tex_创建纹理采样器(ctx);
	//		S_节点数据::g_字体_小.m_Tex = f_tex_创建图像纹理(ctx, { 16,16,1 }, E_纹理格式::e_tf_R8U_归一化, E_纹理维度类型::e_2D_Array);
	//		S_节点数据::g_字体_小.m_字号 = 14;
	//
	//		f_tex_安装纹理采样器(S_节点数据::g_字体_小.m_Tex, S_节点数据::g_字体纹理采样器);
	//
	//
	//		std::wstring 所有字符;
	//		所有字符.resize(0xffff);
	//		for (uint32 i = 0; i < 0xffff; ++i) {
	//			所有字符[i] = i;
	//		}
	//		S_字体加载参数 字体加载参数;
	//		字体加载参数.m_名称 = "默认小字体";
	//		字体加载参数.m_字体文件路径 = f_WStringToString(S_引擎配置::g_系统目录) + "/Fonts/msyh.ttc"; 
	//		字体加载参数.m_字号 = S_节点数据::g_字体_小.m_字号;
	//		f_surface_加链字体纹理(ctx, S_节点数据::g_字体_小, 字体加载参数, 所有字符);
	//
	//
	//		S_节点数据::g_小字体纹理UV = f_bm_alloc(f_buf_getGlobal().g_iVec4动态属性_点, 0);
	//
	//		std::vector<ivec4> 字符纹理坐标(0xffff);
	//		std::vector<uvec2> 字符纹理大小(0xffff);
	//		for (uint32 i = 0; i < 0xffff; ++i) {
	//			vec3 uv = S_节点数据::g_字体_小.m_uv偏移[i];
	//			vec2 bo = S_节点数据::g_字体_小.m_字符大小[i];
	//
	//			int32 顶边偏移 = (S_节点数据::g_字体_小.m_区域[i].顶边) << 16;
	//			
	//			字符纹理坐标[i] = { int32(uv.x), int32(uv.y), int32(uv.z), int32(bo.x) | 顶边偏移 };
	//		}
	//		f_gbuf_fill(S_节点数据::g_小字体纹理UV, 字符纹理坐标.data(), 0, 字符纹理坐标.size());
	//	}
	}


}

void f_NodeCtx_释放物体材质() {
	//delete S_节点数据::g_单色平直面材质;
	//delete S_节点数据::g_单色面材质;
	//delete S_节点数据::g_单色线框材质;
	//delete S_节点数据::g_单色描边材质;
	//delete S_节点数据::g_单色线段材质;
	//delete S_节点数据::g_单色连续线材质;
	//delete S_节点数据::g_单色连续虚线材质;
	//delete S_节点数据::g_单色线段虚线材质;
	//
	//delete S_节点数据::g_基本光照描边材质;
	//delete S_节点数据::g_基本光照轮廓材质;
	//
	//delete S_节点数据::g_基本光照平面材质;
	//delete S_节点数据::g_AABB材质;
	//delete S_节点数据::g_权重可视面材质;
	//delete S_节点数据::g_权重可视线材质;
	//
	//delete S_节点数据::g_单色点材质;
	//
	//delete S_节点数据::g_索引绘制_颜色线材质;
	//
	//
	//
	//delete S_节点数据::g逐顶点线段材质;
	//delete S_节点数据::g逐顶点线段材质_朝向镜头;
	//delete S_节点数据::g逐顶点连续线材质;
	//delete S_节点数据::g逐顶点_点材质;
	//delete S_节点数据::g_逐顶点线段描边材质;
	//delete S_节点数据::g数值标注材质;


	//f_df_销毁材质着色器(S_节点数据::g物理光照轮廓材质);
	//f_material_releasePBR(S_节点数据::g物理光照轮廓材质);
}


void f_NodeCtx_初始化物体公用网格(S_设备环境& ctx) {
	f_buf_getGlobal().g_me_包围盒网格 = f_surface_创建网格对象(nullptr, ctx, false, E_网格数据枚举::e_Mesh_Vulkan);
	
	std::vector<S_VNTC> 顶点;
	std::vector<uint32> 索引;
	f_graph_立方体线段(顶点, 索引, {1,1,1}, {});

	for (auto& e : 顶点) {
		e.uv_color.z = UintBitFloat(f_PackData4X8({255,255,255,255}));
	}


	f_me_fill顶点(f_buf_getGlobal().g_me_包围盒网格, 顶点);
	f_me_fill索引(f_buf_getGlobal().g_me_包围盒网格, 索引);

	return;

	S_节点数据::g_me_摄像机锥形 = f_node_虚拟体网格创建_摄像机锥形(ctx);
	S_节点数据::g_me_铰链轴 = f_node_虚拟体网格创建_铰链轴(ctx);
	S_节点数据::g_me_立方体 = f_node_虚拟体网格创建_立方体(ctx);
	S_节点数据::g_me_圆柱体 = f_node_虚拟体网格创建_圆柱体(ctx);
	S_节点数据::g_me_球体 = f_node_虚拟体网格创建_球体(ctx);
	S_节点数据::g_me_平面 = f_node_虚拟体网格创建_平面(ctx);
	S_节点数据::g_me_胶囊 = f_node_虚拟体网格创建_胶囊(ctx);
	S_节点数据::g_me_链接线 = f_node_虚拟体网格创建_链接线(ctx);
	S_节点数据::g_me_灯光圆 = f_node_虚拟体网格创建_灯光圆(ctx);
	S_节点数据::g_me_灯光平行线 = f_node_虚拟体网格创建_灯光平行线(ctx);
	S_节点数据::g_me_区域光四边线 = f_node_虚拟体网格创建_区域光四边线(ctx);
	S_节点数据::g_me_四边型 = f_node_虚拟体网格创建_四边线(ctx);
	S_节点数据::g_me_十字叉 = f_node_虚拟体网格创建_十字叉(ctx);
	S_节点数据::g_me_范围圆 = f_node_虚拟体网格创建_范围圆(ctx);
	S_节点数据::g_me_胶囊封套端 = f_node_虚拟体网格创建_胶囊封套端(ctx);
	S_节点数据::g_me_胶囊封套管 = f_node_虚拟体网格创建_胶囊封套管(ctx);
	S_节点数据::g_me_边界框 = f_node_虚拟体网格创建_边界框(ctx);

	S_节点数据::g_me_虚拟体_X箭头 = f_node_虚拟体网格创建_箭头(ctx, E_轴向::e_X);
	S_节点数据::g_me_虚拟体_Y箭头 = f_node_虚拟体网格创建_箭头(ctx, E_轴向::e_Y);
	S_节点数据::g_me_虚拟体_Z箭头 = f_node_虚拟体网格创建_箭头(ctx, E_轴向::e_Z);
	S_节点数据::g_me_虚拟体_X旋转箭头 = f_node_虚拟体网格创建_旋转箭头(ctx, E_轴向::e_X);
	S_节点数据::g_me_虚拟体_Y旋转箭头 = f_node_虚拟体网格创建_旋转箭头(ctx, E_轴向::e_Y);
	S_节点数据::g_me_虚拟体_Z旋转箭头 = f_node_虚拟体网格创建_旋转箭头(ctx, E_轴向::e_Z);

	

	S_节点数据::g_me_物理体_立方体 = f_surface_创建实例(S_节点数据::g_me_立方体);
	S_节点数据::g_me_物理体_圆柱体 = f_surface_创建实例(S_节点数据::g_me_圆柱体);
	S_节点数据::g_me_物理体_球体 = f_surface_创建实例(S_节点数据::g_me_球体);
	S_节点数据::g_me_物理体_平面 = f_surface_创建实例(S_节点数据::g_me_平面);
	S_节点数据::g_me_物理体_胶囊 = f_surface_创建实例(S_节点数据::g_me_胶囊);
}

void f_NodeCtx_释放物体公用网格() {
	f_surface_销毁网格(f_buf_getGlobal().g_me_包围盒网格);

	return;
	f_surface_销毁网格(S_节点数据::g_me_摄像机锥形);
	f_surface_销毁网格(S_节点数据::g_me_链接线);
	f_surface_销毁网格(S_节点数据::g_me_范围圆);
	f_surface_销毁网格(S_节点数据::g_me_胶囊封套端);
	f_surface_销毁网格(S_节点数据::g_me_胶囊封套管);

	f_surface_销毁网格(S_节点数据::g_me_物理体_立方体);
	f_surface_销毁网格(S_节点数据::g_me_物理体_圆柱体);
	f_surface_销毁网格(S_节点数据::g_me_物理体_球体);
	f_surface_销毁网格(S_节点数据::g_me_物理体_平面);
	f_surface_销毁网格(S_节点数据::g_me_物理体_胶囊);

	f_surface_销毁网格(S_节点数据::g_me_立方体);
	f_surface_销毁网格(S_节点数据::g_me_圆柱体);
	f_surface_销毁网格(S_节点数据::g_me_球体);
	f_surface_销毁网格(S_节点数据::g_me_平面);
	f_surface_销毁网格(S_节点数据::g_me_胶囊);

	f_surface_销毁网格(S_节点数据::g_me_虚拟体_X箭头);
	f_surface_销毁网格(S_节点数据::g_me_虚拟体_Y箭头);
	f_surface_销毁网格(S_节点数据::g_me_虚拟体_Z箭头);
	f_surface_销毁网格(S_节点数据::g_me_虚拟体_X旋转箭头);
	f_surface_销毁网格(S_节点数据::g_me_虚拟体_Y旋转箭头);
	f_surface_销毁网格(S_节点数据::g_me_虚拟体_Z旋转箭头);
}

void f_NodeCtx_set当前帧(int64 帧, float32 子帧) {
	S_节点数据::g_场景帧.当前帧 = 帧;
	S_节点数据::g_场景帧.子帧 = 子帧;
}

void f_NodeCtx_set帧区间(ivec2 区间) {
	S_节点数据::g_场景帧.帧区间 = 区间;
}






S_时间帧& f_NodeCtx_get帧() {
	return S_节点数据::g_场景帧;
}

void f_NodeCtx_set场景当前时间(int32 t) {
	S_节点数据::g_场景帧.当前帧 = t;

	S_物体::g_更新曲线关键帧 = true;
	//S_物体::g_当前帧 = t;

	f_an_更新属性关键帧();
}


static void f_set骨骼焦点颜色(S_物体* ob, const S_RGBA8UI& c) {
	if (ob->m_Type == E_物体类型::t_骨骼) {
		if (ob->m_DataNum > 2) {
			f_ob_set颜色2(ob, c, ob->m_实例ID, E_物体网格元素类型::e_MT_框);
		}
		f_ob_set颜色2(ob, c, ob->m_实例ID, E_物体网格元素类型::e_MT_面);

	}
	else {
		//f_ob_set颜色2(ob, c, ob->m_实例ID, 0);
	}
	
	for (auto& e : ob->m_子物体) {
		f_set骨骼焦点颜色(static_cast<S_物体*>(e), c);
	}
}

//void f_NodeCtx_set选中物体(std::set<S_物体*>& objs, bool 添加) {
//	if (添加) {
//	}
//	else {
//		f_NodeCtx_clear选中物体();
//		//if (S_节点数据::g_选中物体.empty() && objs.size()) {
//		//	S_节点数据::g_激活物体 = *objs.begin();
//		//}
//	}
//
//	for (auto& e : objs) {
//		switch (e->m_Type) {
//			case E_物体类型::t_实例:
//			case E_物体类型::t_多边形:
//			case E_物体类型::t_网格物体: {
//				f_ob_set颜色2(e, S_节点UI主题::uic_模型焦点, e->m_实例ID, E_物体网格元素类型::e_MT_焦点);
//				f_ob_set颜色2(e, S_节点UI主题::uic_模型焦点, e->m_实例ID, E_物体网格元素类型::e_MT_框);
//				break;
//			}
//
//			case E_物体类型::t_点:
//			case E_物体类型::t_灯光:
//			case E_物体类型::t_虚拟体: {
//				f_ob_set颜色2(e, S_节点UI主题::uic_模型焦点, e->m_实例ID, E_物体网格元素类型::e_MT_焦点);
//				break;
//			}
//
//			case E_物体类型::t_骨架: {
//				for (auto& se : e->m_子物体) {
//					f_set骨骼焦点颜色(static_cast<S_物体*>(se), S_节点UI主题::uic_模型焦点);
//				}
//				break;
//			}
//			default:
//				break;
//		}
//		e->m_选中 = true;
//	}
//
//}
void f_NodeCtx_set选中物体(const std::vector<S_物体*>& objs, bool 添加) {
	if (添加) {
		//S_节点数据::g_选中激活物体.insert(S_节点数据::g_选中激活物体.end(), objs.begin(), objs.end());
	}
	else {
		f_NodeCtx_clear选中物体();
	}

	for (auto& e : objs) {
		switch (e->m_Type) {
			case E_物体类型::t_实例:
			case E_物体类型::t_多边形:
			case E_物体类型::t_网格物体: {
				switch (e->m_附属类型) {
					case E_物体类型::t_灯光:
					case E_物体类型::t_包围盒: {
						goto To_虚拟体;
					}
				}
				f_ob_set颜色2(e, S_节点UI主题::uic_模型焦点, e->m_实例ID, E_物体网格元素类型::e_MT_焦点);
				f_ob_set颜色2(e, S_节点UI主题::uic_模型焦点, e->m_实例ID, E_物体网格元素类型::e_MT_框);
				break;
			}

			case E_物体类型::t_点光源:
			case E_物体类型::t_聚光灯:
			case E_物体类型::t_区域光:
			case E_物体类型::t_平行光:
				for (uint32 i = 0; i < e->m_DataNum; ++i) {
					f_ob_set颜色2(e, S_节点UI主题::uic_模型焦点, e->m_实例ID, i);
				}
				break;

			case E_物体类型::t_点: 
			case E_物体类型::t_灯光:
			case E_物体类型::t_虚拟体: {
				To_虚拟体:
				for (uint32 i = 0; i < e->m_DataNum; ++i) {
					auto me = f_ob_getMesh(e, i);
					e->m_颜色 = me->m_Color + S_RGBA8UI{200, 200, 100, 0};
					f_ob_set颜色2(e, e->m_颜色, e->m_实例ID, i);
				}
				break;
			}

			case E_物体类型::t_骨架: {
				for (auto& se : e->m_子物体) {
					f_set骨骼焦点颜色(static_cast<S_物体*>(se), S_节点UI主题::uic_模型焦点);
				}
				break;
			}

			case E_物体类型::t_空间曲线: {
				f_buf_网格元素变换属性_at(f_ob_getMesh(e, 0)->m_网格元素变换属性).m_Color = f_PackData4X8(S_节点UI主题::uic_模型焦点);
				break;
			}
			default:
				break;
		}
		e->m_选中 = true;
	}
}

void f_NodeCtx_clear选中物体() {
	
}


void f_NodeCtx_set选中编辑物体(S_物体* ob, int32 元素, bool 添加) {
	if (!添加) {
		f_NodeCtx_clear选中编辑物体();
	}

	
	S_节点数据::g_编辑物体.insert(ob);
	
	uint32 实例ID = ob->m_实例ID;
	if (E_物体类型::t_实例 == ob->m_Type) {
		ob = f_ob_get实例父对象(ob);
	}

	switch (ob->m_Type) {
		case E_物体类型::t_骨节: {
			f_ob_set颜色2(ob, S_节点UI主题::uic_模型焦点, 实例ID, E_物体网格元素类型::e_MT_焦点);
			f_ob_set颜色2(ob, S_节点UI主题::uic_模型焦点, 实例ID, E_物体网格元素类型::e_MT_面);

			ob->m_网格拾取元素 = E_物体网格元素类型::e_MT_焦点;
			break;
		}
		case E_物体类型::t_骨骼: {
			auto* 骨骼 = f_ob_from骨骼(ob);

			if (元素 == 0 || 骨骼->m_根骨骼) {
				f_ob_set颜色2(ob, S_节点UI主题::uic_模型焦点, 实例ID, E_物体网格元素类型::e_MT_焦点);
				f_ob_set颜色2(ob, S_节点UI主题::uic_模型焦点, 实例ID, E_物体网格元素类型::e_MT_面);

				ob->m_网格拾取元素 = E_物体网格元素类型::e_MT_焦点;
			}
			else {
				f_ob_set颜色2(ob, S_节点UI主题::uic_模型焦点, 实例ID, E_物体网格元素类型::e_MT_边);
				f_ob_set颜色2(ob, S_节点UI主题::uic_模型焦点, 实例ID, E_物体网格元素类型::e_MT_框);

				ob->m_网格拾取元素 = E_物体网格元素类型::e_MT_边;
			}

			if (ob->m_骨架) {
				S_BonePose* 骨骼姿态 = f_buf_骨骼姿态_ptr(ob->m_骨架->m_姿态);
				auto& t = 骨骼姿态[ob->m_ID];
				t.select = 1;
			}

			
			if (骨骼) {
				骨骼->m_封套范围线->m_显示 = true;
			}

			break;
		}
		default:
			break;
	}
}

void f_NodeCtx_clear选中编辑物体() {
	for (auto* ob : S_节点数据::g_编辑物体) {
		uint32 实例ID = ob->m_实例ID;
		if (E_物体类型::t_实例 == ob->m_Type) {
			ob = f_ob_get实例父对象(ob);
		}

		switch (ob->m_Type) {
			case E_物体类型::t_骨节: {
				f_ob_set颜色2(ob, S_RGBA8UI{ 200, 200, 200, 255 }, 实例ID, E_物体网格元素类型::e_MT_焦点);
				f_ob_set颜色2(ob, S_RGBA8UI{ 1, 1, 1, 255 }, 实例ID, E_物体网格元素类型::e_MT_面);
				break;
			}
			case E_物体类型::t_骨骼: {
				if (ob->m_DataNum > 2) {
					f_ob_set颜色2(ob, S_RGBA8UI{ 128, 128, 128, 255 }, 实例ID, E_物体网格元素类型::e_MT_边);
					f_ob_set颜色2(ob, S_RGBA8UI{ 1, 1, 1, 255 }, 实例ID, E_物体网格元素类型::e_MT_框);
				}
				f_ob_set颜色2(ob, S_RGBA8UI{ 128, 128, 128, 255 }, 实例ID, E_物体网格元素类型::e_MT_焦点);
				f_ob_set颜色2(ob, S_RGBA8UI{ 1, 1, 1, 255 }, 实例ID, E_物体网格元素类型::e_MT_面);


				if (ob->m_骨架) {
					S_BonePose* 骨骼姿态 = f_buf_骨骼姿态_ptr(ob->m_骨架->m_姿态);
					auto& t = 骨骼姿态[ob->m_ID];
					t.select = 0;
				}

				auto* 骨骼 = f_ob_from骨骼(ob);
				if (骨骼) {
					骨骼->m_封套范围线->m_显示 = false;
				}
				break;
			}
			 
		}
	}

	S_节点数据::g_编辑物体.clear();
}


void f_NodeCtx_set选中辅助编辑物体(S_物体* ob, int32 元素, bool 添加) {

}

void f_NodeCtx_clear选中辅助编辑物体() {

}


//S_节点数据::g_辅助编辑物体

S_物体* f_NodeCtx_get骨骼骨架对象(S_物体* 骨骼) {
	if (骨骼->m_父对象) {
		if (static_cast<S_物体*>(骨骼->m_父对象)->m_Type == E_物体类型::t_骨架) {
			return static_cast<S_物体*>(骨骼->m_父对象);
		}
		else {
			return f_NodeCtx_get骨骼骨架对象(static_cast<S_物体*>(骨骼->m_父对象));
		}
	}
	return nullptr;
}



void f_NodeCtx_录物体类节点(C_节点基类* 节点) {
	if (节点->m_Type >= E_节点类型::e_节点Type_空物体) {
		auto e = 节点->f_虚拟体();
		if (e) {
			g_能在场景视口中显示的物体节点[e] = 节点;
		}
	}
}

void f_NodeCtx_录物体类节点(C_节点基类* 节点, S_物体* ob) {
	if (节点->m_Type >= E_节点类型::e_节点Type_空物体) {
		g_能在场景视口中显示的物体节点[ob] = 节点;
	}
}

void f_NodeCtx_清除物体类节点(S_物体* ob) {
	g_能在场景视口中显示的物体节点.erase(ob);
}

std::vector<C_节点基类*> f_NodeCtx_从可视物体取节点(const std::vector<S_物体*>& obs) {
	std::vector<C_节点基类*> planes;
	for (auto ob : obs) {
		if(g_能在场景视口中显示的物体节点.find(ob) != g_能在场景视口中显示的物体节点.end()) planes.push_back(g_能在场景视口中显示的物体节点[ob]);
	}
	return planes;
}

std::vector<C_节点基类*> f_NodeCtx_从可视物体取节点(const std::set<S_物体*>& obs) {
	std::vector<C_节点基类*> planes;
	for (auto ob : obs) {
		if (g_能在场景视口中显示的物体节点.find(ob) != g_能在场景视口中显示的物体节点.end()) planes.push_back(g_能在场景视口中显示的物体节点[ob]);
	}
	return planes;
}






S_材质管线* f_NodeCtx_get单色点材质() {
	return S_节点数据::g_单色点材质;
}
S_材质管线* f_NodeCtx_get单色线材质() {
	return S_节点数据::g_单色线框材质;
}
S_材质管线* f_NodeCtx_get单色面材质() {
	return S_节点数据::g_单色面材质;
}
S_材质管线* f_NodeCtx_get单色平直面材质() {
	return S_节点数据::g_单色平直面材质;
}
S_材质管线* f_NodeCtx_get单色描边材质() {
	return S_节点数据::g_单色描边材质;
}



S_材质管线* f_NodeCtx_get单色线段材质() {
	return S_节点数据::g_单色线段材质;
}

S_材质管线* f_NodeCtx_get单色连续线材质() {
	return S_节点数据::g_单色连续线材质;
}

S_材质管线* f_NodeCtx_get单色连续虚线材质() {
	return S_节点数据::g_单色连续虚线材质;
}

S_材质管线* f_NodeCtx_get单色线段虚线材质() {
	return S_节点数据::g_单色线段虚线材质;
}



S_材质管线* f_NodeCtx_get数值标注材质() {
	return S_节点数据::g数值标注材质;
}
S_材质管线* f_NodeCtx_get数值标注线材质() {
	return S_节点数据::g数值标注线材质;
}

S_材质管线* f_NodeCtx_get包围盒材质() {
	return S_节点数据::g包围盒材质;
}

S_材质管线* f_NodeCtx_getFLIP调试预览材质() {
	return S_节点数据::gFLIP可视预览材质;
}

S_材质管线* f_NodeCtx_get物理光照轮廓材质() {
	return S_节点数据::g物理光照轮廓材质;
}

S_材质管线* f_NodeCtx_get物理光照线材质(){
	return nullptr;
}




S_材质管线* f_NodeCtx_get基本光照线段材质() {
	return f_g_预设材质().g_基本光照线段材质;
}

S_材质管线* f_NodeCtx_get基本光照描边材质() {
	return S_节点数据::g_基本光照描边材质;
}

S_材质管线* f_NodeCtx_get基本光照线材质() {
	return f_g_预设材质().g_基本光照线材质;
}

S_材质管线* f_NodeCtx_get基本光照面材质() {
	return f_g_预设材质().g_基本光照面材质;
}

S_材质管线* f_NodeCtx_get基本光照点材质() {
	return f_g_预设材质().g_基本光照点材质;
}

S_材质管线* f_NodeCtx_get基本平直面光照材质() {
	return S_节点数据::g_基本光照平面材质;
}

S_材质管线* f_NodeCtx_get基本光照面轮廓材质() {
	return S_节点数据::g_基本光照轮廓材质;
}

S_材质管线* f_NodeCtx_getAABB材质() {
	return S_节点数据::g_AABB材质;
}

S_材质管线* f_NodeCtx_get权重可视线材质() {
	return S_节点数据::g_权重可视线材质;
}
S_材质管线* f_NodeCtx_get权重可视面材质() {
	return S_节点数据::g_权重可视面材质;
}

S_材质管线* f_NodeCtx_get索引绘制_颜色线材质(bool 线段) {
	return 线段 ? S_节点数据::g_索引绘制_颜色线段材质 : S_节点数据::g_索引绘制_颜色线材质;
}

S_材质管线* f_NodeCtx_get索引绘制_颜色点材质() {
	return S_节点数据::g_索引绘制_颜色点材质;
}

S_材质管线* f_NodeCtx_get图标材质() {
	return S_节点数据::g_索引绘制_图标材质;
}

S_材质管线* f_NodeCtx_get逐顶点线段材质(bool 统一朝向) {
	if (统一朝向) return S_节点数据::g逐顶点线段材质_朝向镜头;
	return S_节点数据::g逐顶点线段材质;
}
S_材质管线* f_NodeCtx_get逐顶点连续线材质() {
	return S_节点数据::g逐顶点连续线材质;
}
S_材质管线* f_NodeCtx_get逐顶点点材质() {
	return S_节点数据::g逐顶点_点材质;
}

S_材质管线* f_NodeCtx_get线段描边材质() {
	return S_节点数据::g_逐顶点线段描边材质;
}

S_材质管线* f_NodeCtx_get逐顶点曲线材质() {
	return S_节点数据::g曲线材质;
}
S_材质管线* f_NodeCtx_get逐顶点曲线控制点材质() {
	return S_节点数据::g曲线控制点材质;
}
S_材质管线* f_NodeCtx_get逐顶点曲线控制线材质() {
	return S_节点数据::g曲线控制线材质;
}


S_材质管线* f_NodeCtx_get灯光模型中心圆材质(S_设备环境& ctx) {
	static S_材质管线* 灯光模型线段 = nullptr;
	if (!灯光模型线段) {
		灯光模型线段 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画线段);
	}
	return 灯光模型线段;
}
S_材质管线* f_NodeCtx_get灯光模型范围线材质(S_设备环境& ctx) {
	static S_材质管线* 灯光模型线 = nullptr;
	if (!灯光模型线) {
		灯光模型线 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画线段);
	}
	return 灯光模型线;
}
S_材质管线* f_NodeCtx_get灯光模型方向线材质(S_设备环境& ctx) {
	static S_材质管线* 灯光模型线 = nullptr;
	if (!灯光模型线) {
		灯光模型线 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画线段);
	}
	return 灯光模型线;
}
S_材质管线* f_NodeCtx_get区域灯光模型点材质(S_设备环境& ctx) {
	return nullptr;
}

S_材质管线* f_NodeCtx_get单虚拟体材质(S_设备环境& ctx) {
	static S_材质管线* 单虚拟体线材质 = nullptr;
	if (!单虚拟体线材质) {
		单虚拟体线材质 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画线段);
	}
	return 单虚拟体线材质;
}




S_材质管线* f_NodeCtx_get虚拟体中心圆材质(S_设备环境& ctx) {
	static S_材质管线* 虚拟体中心圆 = nullptr;
	if (!虚拟体中心圆) {
		虚拟体中心圆 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画线段);
	}
	return 虚拟体中心圆;
}
S_材质管线* f_NodeCtx_get虚拟体范围线材质(S_设备环境& ctx) {
	static S_材质管线* 虚拟体范围线 = nullptr;
	if (!虚拟体范围线) {
		虚拟体范围线 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画线段);
	}
	return 虚拟体范围线;
}
S_材质管线* f_NodeCtx_get虚拟体方向线材质(S_设备环境& ctx) {
	static S_材质管线* 虚拟体方向线 = nullptr;
	if (!虚拟体方向线) {
		虚拟体方向线 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画线段);
	}
	return 虚拟体方向线;
}




S_材质管线* f_NodeCtx_get单元素虚拟体材质(S_设备环境& ctx) {
	static S_材质管线* 单元素虚拟体 = nullptr;
	if (!单元素虚拟体) {
		单元素虚拟体 = new S_线逐顶点有色线段材质(ctx, true, E_绘制方式::e_画线段);
	}
	return 单元素虚拟体;
}




void f_NodeCtx_删除物体到回收站(S_物体* ob) {
	ob->m_父对象 = nullptr;

	for (auto& sob : ob->m_子物体) {
		f_NodeCtx_删除物体到回收站(static_cast<S_物体*>(sob));
	}
	f_ob_清除子物体(ob);

	S_节点数据::g_删除物体.push(ob);
}

S_物体* f_NodeCtx_回收物体() {
	S_物体* ob = nullptr;

	if (S_节点数据::g_删除物体.size()) {
		ob = S_节点数据::g_删除物体.top();
		S_节点数据::g_删除物体.pop();
	}
	
	return ob;
}


void f_NodeCtx_set物体全局显示模式(S_物体* ob, uint32 模式位域) {
	f_NodeCtx_物体全局显示模式(ob, 模式位域);
	
	uint32 num = ob->m_子物体.size();
	auto* objs = ob->m_子物体.data();
	for (uint32 i = 0; i < num; ++i) f_NodeCtx_set物体全局显示模式(static_cast<S_物体*>(objs[i]), 模式位域);
}


void f_NodeCtx_物体显示模式(S_物体* ob, uint32 模式位域) {
	switch (ob->m_Type) {
		case E_物体类型::t_虚拟体:
		case E_物体类型::t_网格物体:
		case E_物体类型::t_多边形:
			ob->m_视口显示模式 = (ob->m_视口显示模式 & 0xffff0000) | 模式位域;
			break;

		default: break;
	}
}

void f_NodeCtx_物体全局显示模式(S_物体* ob, uint32 模式位域) {
	switch (ob->m_附属类型) {
		case E_物体类型::t_包围盒: {
			return;
		}
		default:
			break;
	}

	switch (ob->m_Type) {
		case E_物体类型::t_虚拟体: {
			
			break;
		}
		case E_物体类型::t_网格物体:
		case E_物体类型::t_多边形:
			ob->m_视口显示模式 = (ob->m_视口显示模式 & 0x0000ffff) | (模式位域<<16);
			break;

		case E_物体类型::t_骨架:
		case E_物体类型::t_骨骼: {
			if (模式位域 & E_物体视口显示::e_OVS_面) {
				ob->m_视口显示模式 =
					E_物体视口显示::e_OVS_轮廓
					| E_物体视口显示::e_OVS_面
					| E_物体视口显示::e_OVS_边
					| E_物体视口显示::e_OVS_边框
					;

				ob->m_视口显示模式 |= (ob->m_视口显示模式 << 16);

				f_ob_set线宽(ob, 3.0, E_物体网格元素类型::e_MT_面);
				if(ob->m_DataNum > 2) {
					f_ob_set线宽(ob, 3.0, E_物体网格元素类型::e_MT_框);
				}
			}
			else {
				ob->m_视口显示模式 = E_物体视口显示::e_OVS_面 | E_物体视口显示::e_OVS_边框;
				ob->m_视口显示模式 |= (ob->m_视口显示模式 << 16);

				f_ob_set线宽(ob, 1.5, E_物体网格元素类型::e_MT_面);
				if (ob->m_DataNum > 2) {
					f_ob_set线宽(ob, 1.5, E_物体网格元素类型::e_MT_框);
				}
			}
			break;
		}
		default: break;
	}
}

void f_NodeCtx_物体线模式显示(S_物体* ob) {
	if (f_ob_get数量层数量(ob) > 2) {
		ob->f_打开可视通道(0);
		ob->f_关闭可视通道(1);
		ob->f_打开可视通道(2);
	}
	else {
		ob->f_打开可视通道(0);
		ob->f_关闭可视通道(1);
	}
}

void f_NodeCtx_物体面模式显示(S_物体* ob) {
	if (f_ob_get数量层数量(ob) > 2) {
		ob->f_打开可视通道(0);
		ob->f_打开可视通道(1);
		ob->f_关闭可视通道(2);
	}
	else {
		ob->f_打开可视通道(0);
		ob->f_关闭可视通道(1);
	}
}

void f_NodeCtx_物体线面模式显示(S_物体* ob) {
	if (f_ob_get数量层数量(ob) > 2) {
		ob->f_打开可视通道(0);
		ob->f_打开可视通道(1);
		ob->f_打开可视通道(2);
	}
	else {
		ob->f_打开可视通道(0);
		ob->f_打开可视通道(1);
	}
}


void f_NodeCtx_set物体全局显示模式(uint32 模式位域) {
	for (auto& e : f_scene_get集合物体(f_NodeCtx_get默认场景())) {
		f_NodeCtx_set物体全局显示模式(e, 模式位域);
	}
}

void f_NodeCtx_set物体全局渲染模式(uint32 物体显示模式, E_物体渲染模式 模式) {
	for (auto& e : f_scene_get集合物体(f_NodeCtx_get默认场景())) {
		//uint32 全局模式位域 = (e->m_视口显示模式 & 0xffff);
		uint32 全局模式位域 = 0;
		
		switch (模式) {
			case E_物体渲染模式::e_渲染模式_白模: {
				全局模式位域 |= 物体显示模式;
				全局模式位域 |= E_物体视口显示::e_OVS_面;
				break;
			}
			case E_物体渲染模式::e_渲染模式_纹理: {
				break;
			}
			case E_物体渲染模式::e_渲染模式_光栅: {
				全局模式位域 = E_物体视口显示::e_OVS_光照;
				break;
			}
			case E_物体渲染模式::e_渲染模式_光追: {
				全局模式位域 |= E_物体视口显示::e_OVS_光照;
				全局模式位域 |= E_物体视口显示::e_OVS_预览;
				全局模式位域 |= E_物体视口显示::e_OVS_渲染;
				break;
			}
			default: break;
		}
		
		f_NodeCtx_set物体全局显示模式(e, 全局模式位域);
	}
}





S_节点UI主题::S_节点UI主题() {
}





void f_update轮廓着色器参数配置(S_材质管线* mat, S_物体* ob, S_Mesh* me, uint8 元素, uint32 多维子元素) {
	f_df_allocGPU参数缓存槽(&me->m_多维材质槽[多维子元素].m_参数槽, 21);

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[2] = &ob->m_实例颜色[元素];
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[2] = DEF_BINDING_WIDGET_Color;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[2] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[2] = 1;

	f_update着色器_骨骼配置(ob, me, 多维子元素, 3);

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[6] = &me->m_网格元素变换属性;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[6] = DEF_BINDING_LineProp;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[6] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[6] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[7] = &f_buf_getGlobal().g_全局绑定参数;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[7] = DEF_BINDING_Render_GlobalParam;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[7] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[7] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[8] = &f_buf_getGlobal().m_材质;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[8] = DEF_MaterialsBindID;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[8] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[8] = 1;


	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[9] = me->m_面;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[9] = DEF_BINDING_TasterBindID_Face;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[9] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[9] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[10] = me->m_UV;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[10] = DEF_BINDING_TasterBindID_TexCoord;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[10] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[10] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[11] = me->m_UV索引;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[11] = DEF_BINDING_TasterBindID_TexIndex;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[11] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[11] = 1;


	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[12] = me->m_自定义属性索引;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[12] = DEF_BINDING_Face_AttrIndex;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[12] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[12] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[13] = &me->m_多维材质槽[多维子元素].m_Material->m_材质自定义属性索引;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[13] = DEF_BINDING_Material_AttrIndex;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[13] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[13] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[14] = me->m_网格属性;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[14] = DEF_BINDING_ObMesh;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[14] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[14] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[15] = &f_buf_getGlobal().g_透明链表计数;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[15] = DEF_TasterBindID_AlphaListCount;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[15] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[15] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[16] = f_buf_getGlobal().g_透明链表纹理;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[16] = DEF_TasterTexturesBindID_rgba32ui;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[16] = E_板载缓存类型::e_图像缓存;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[16] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[17] = f_buf_getGlobal().g_透明链表头;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[17] = DEF_TasterTexturesBindID_r32ui;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[17] = E_板载缓存类型::e_IMAGE;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[17] = 1;



	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[18] = me->m_邻接面索引;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[18] = DEF_BINDING_Face_AdjacencyID_BindID;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[18] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[18] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[19] = me->m_面法线;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[19] = DEF_BINDING_Face_Normal_BindID;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[19] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[19] = 1;

	me->m_多维材质槽[多维子元素].m_参数槽.m_参数槽[20] = me->m_面中心;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定位置[20] = DEF_BINDING_Face_Center_BindID;
	me->m_多维材质槽[多维子元素].m_参数槽.m_参数类型[20] = E_板载缓存类型::e_SSBO;
	me->m_多维材质槽[多维子元素].m_参数槽.m_绑定数量[20] = 1;



	me->m_多维材质槽[多维子元素].m_参数槽.m_纹理槽 = &f_buf_getGlobal().g_全局模型纹理槽;
}


